home *** CD-ROM | disk | FTP | other *** search
/ OpenGL Superbible (2nd Edition) / OpenGL SuperBible e2.iso / tools / Mesa-3.0 / SRC / PIXEL.C < prev    next >
Encoding:
C/C++ Source or Header  |  1998-07-17  |  21.7 KB  |  793 lines
  1. /* $Id: pixel.c,v 3.6 1998/07/17 03:23:47 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  3.0
  6.  * Copyright (C) 1995-1998  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * $Log: pixel.c,v $
  26.  * Revision 3.6  1998/07/17 03:23:47  brianp
  27.  * added a bunch of const's
  28.  *
  29.  * Revision 3.5  1998/03/27 04:17:31  brianp
  30.  * fixed G++ warnings
  31.  *
  32.  * Revision 3.4  1998/03/22 16:42:05  brianp
  33.  * added 8-bit CI->RGBA pixel mapping tables
  34.  *
  35.  * Revision 3.3  1998/02/08 20:21:42  brianp
  36.  * added a bunch of rgba, ci and stencil scaling, biasing and mapping functions
  37.  *
  38.  * Revision 3.2  1998/02/01 22:27:57  brianp
  39.  * removed obsolete call to update_drawpixels_state()
  40.  *
  41.  * Revision 3.1  1998/02/01 22:15:39  brianp
  42.  * moved pixel zoom code into zoom.c
  43.  *
  44.  * Revision 3.0  1998/01/31 21:00:28  brianp
  45.  * initial rev
  46.  *
  47.  */
  48.  
  49.  
  50. /*
  51.  * glPixelStore, glPixelTransfer, glPixelMap, glPixelZoom, etc.
  52.  */
  53.  
  54.  
  55. #ifdef PC_HEADER
  56. #include "all.h"
  57. #else
  58. #include <assert.h>
  59. #include <stdio.h>
  60. #include <stdlib.h>
  61. #include "context.h"
  62. #include "macros.h"
  63. #include "pixel.h"
  64. #include "types.h"
  65. #endif
  66.  
  67.  
  68.  
  69. /**********************************************************************/
  70. /*****                    glPixelZoom                             *****/
  71. /**********************************************************************/
  72.  
  73.  
  74.  
  75. void gl_PixelZoom( GLcontext *ctx, GLfloat xfactor, GLfloat yfactor )
  76. {
  77.    if (INSIDE_BEGIN_END(ctx)) {
  78.       gl_error( ctx, GL_INVALID_OPERATION, "glPixelZoom" );
  79.       return;
  80.    }
  81.    ctx->Pixel.ZoomX = xfactor;
  82.    ctx->Pixel.ZoomY = yfactor;
  83. }
  84.  
  85.  
  86.  
  87. /**********************************************************************/
  88. /*****                    glPixelStore                            *****/
  89. /**********************************************************************/
  90.  
  91.  
  92. void gl_PixelStorei( GLcontext *ctx, GLenum pname, GLint param )
  93. {
  94.    /* NOTE: this call can't be compiled into the display list */
  95.  
  96.    if (INSIDE_BEGIN_END(ctx)) {
  97.       gl_error( ctx, GL_INVALID_OPERATION, "glPixelStore" );
  98.       return;
  99.    }
  100.  
  101.    switch (pname) {
  102.       case GL_PACK_SWAP_BYTES:
  103.          ctx->Pack.SwapBytes = param ? GL_TRUE : GL_FALSE;
  104.      break;
  105.       case GL_PACK_LSB_FIRST:
  106.          ctx->Pack.LsbFirst = param ? GL_TRUE : GL_FALSE;
  107.      break;
  108.       case GL_PACK_ROW_LENGTH:
  109.      if (param<0) {
  110.         gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
  111.      }
  112.      else {
  113.         ctx->Pack.RowLength = param;
  114.      }
  115.      break;
  116.       case GL_PACK_SKIP_PIXELS:
  117.      if (param<0) {
  118.         gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
  119.      }
  120.      else {
  121.         ctx->Pack.SkipPixels = param;
  122.      }
  123.      break;
  124.       case GL_PACK_SKIP_ROWS:
  125.      if (param<0) {
  126.         gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
  127.      }
  128.      else {
  129.         ctx->Pack.SkipRows = param;
  130.      }
  131.      break;
  132.       case GL_PACK_ALIGNMENT:
  133.          if (param==1 || param==2 || param==4 || param==8) {
  134.         ctx->Pack.Alignment = param;
  135.      }
  136.      else {
  137.         gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
  138.      }
  139.      break;
  140.       case GL_UNPACK_SWAP_BYTES:
  141.      ctx->Unpack.SwapBytes = param ? GL_TRUE : GL_FALSE;
  142.          break;
  143.       case GL_UNPACK_LSB_FIRST:
  144.      ctx->Unpack.LsbFirst = param ? GL_TRUE : GL_FALSE;
  145.      break;
  146.       case GL_UNPACK_ROW_LENGTH:
  147.      if (param<0) {
  148.         gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
  149.      }
  150.      else {
  151.         ctx->Unpack.RowLength = param;
  152.      }
  153.      break;
  154.       case GL_UNPACK_SKIP_PIXELS:
  155.      if (param<0) {
  156.         gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
  157.      }
  158.      else {
  159.         ctx->Unpack.SkipPixels = param;
  160.      }
  161.      break;
  162.       case GL_UNPACK_SKIP_ROWS:
  163.      if (param<0) {
  164.         gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
  165.      }
  166.      else {
  167.         ctx->Unpack.SkipRows = param;
  168.      }
  169.      break;
  170.       case GL_UNPACK_ALIGNMENT:
  171.          if (param==1 || param==2 || param==4 || param==8) {
  172.         ctx->Unpack.Alignment = param;
  173.      }
  174.      else {
  175.         gl_error( ctx, GL_INVALID_VALUE, "glPixelStore" );
  176.      }
  177.      break;
  178.       default:
  179.      gl_error( ctx, GL_INVALID_ENUM, "glPixelStore" );
  180.    }
  181. }
  182.  
  183.  
  184.  
  185.  
  186.  
  187. /**********************************************************************/
  188. /*****                         glPixelMap                         *****/
  189. /**********************************************************************/
  190.  
  191.  
  192.  
  193. void gl_PixelMapfv( GLcontext *ctx,
  194.                     GLenum map, GLint mapsize, const GLfloat *values )
  195. {
  196.    GLint i;
  197.  
  198.    if (INSIDE_BEGIN_END(ctx)) {
  199.       gl_error( ctx, GL_INVALID_OPERATION, "glPixelMapfv" );
  200.       return;
  201.    }
  202.  
  203.    if (mapsize<0 || mapsize>MAX_PIXEL_MAP_TABLE) {
  204.       gl_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
  205.       return;
  206.    }
  207.  
  208.    if (map>=GL_PIXEL_MAP_S_TO_S && map<=GL_PIXEL_MAP_I_TO_A) {
  209.       /* test that mapsize is a power of two */
  210.       GLuint p;
  211.       GLboolean ok = GL_FALSE;
  212.       for (p=1; p<=MAX_PIXEL_MAP_TABLE; p=p<<1) {
  213.      if ( (p&mapsize) == p ) {
  214.         ok = GL_TRUE;
  215.         break;
  216.      }
  217.       }
  218.       if (!ok) {
  219.      gl_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
  220.          return;
  221.       }
  222.    }
  223.  
  224.    switch (map) {
  225.       case GL_PIXEL_MAP_S_TO_S:
  226.          ctx->Pixel.MapStoSsize = mapsize;
  227.          for (i=0;i<mapsize;i++) {
  228.         ctx->Pixel.MapStoS[i] = (GLint) values[i];
  229.      }
  230.      break;
  231.       case GL_PIXEL_MAP_I_TO_I:
  232.          ctx->Pixel.MapItoIsize = mapsize;
  233.          for (i=0;i<mapsize;i++) {
  234.         ctx->Pixel.MapItoI[i] = (GLint) values[i];
  235.      }
  236.      break;
  237.       case GL_PIXEL_MAP_I_TO_R:
  238.          ctx->Pixel.MapItoRsize = mapsize;
  239.          for (i=0;i<mapsize;i++) {
  240.             GLfloat val = CLAMP( values[i], 0.0, 1.0 );
  241.         ctx->Pixel.MapItoR[i] = val;
  242.         ctx->Pixel.MapItoR8[i] = (GLint) (val * 255.0F);
  243.      }
  244.      break;
  245.       case GL_PIXEL_MAP_I_TO_G:
  246.          ctx->Pixel.MapItoGsize = mapsize;
  247.          for (i=0;i<mapsize;i++) {
  248.             GLfloat val = CLAMP( values[i], 0.0, 1.0 );
  249.         ctx->Pixel.MapItoG[i] = val;
  250.         ctx->Pixel.MapItoG8[i] = (GLint) (val * 255.0F);
  251.      }
  252.      break;
  253.       case GL_PIXEL_MAP_I_TO_B:
  254.          ctx->Pixel.MapItoBsize = mapsize;
  255.          for (i=0;i<mapsize;i++) {
  256.             GLfloat val = CLAMP( values[i], 0.0, 1.0 );
  257.         ctx->Pixel.MapItoB[i] = val;
  258.         ctx->Pixel.MapItoB8[i] = (GLint) (val * 255.0F);
  259.      }
  260.      break;
  261.       case GL_PIXEL_MAP_I_TO_A:
  262.          ctx->Pixel.MapItoAsize = mapsize;
  263.          for (i=0;i<mapsize;i++) {
  264.             GLfloat val = CLAMP( values[i], 0.0, 1.0 );
  265.         ctx->Pixel.MapItoA[i] = val;
  266.         ctx->Pixel.MapItoA8[i] = (GLint) (val * 255.0F);
  267.      }
  268.      break;
  269.       case GL_PIXEL_MAP_R_TO_R:
  270.          ctx->Pixel.MapRtoRsize = mapsize;
  271.          for (i=0;i<mapsize;i++) {
  272.         ctx->Pixel.MapRtoR[i] = CLAMP( values[i], 0.0, 1.0 );
  273.      }
  274.      break;
  275.       case GL_PIXEL_MAP_G_TO_G:
  276.          ctx->Pixel.MapGtoGsize = mapsize;
  277.          for (i=0;i<mapsize;i++) {
  278.         ctx->Pixel.MapGtoG[i] = CLAMP( values[i], 0.0, 1.0 );
  279.      }
  280.      break;
  281.       case GL_PIXEL_MAP_B_TO_B:
  282.          ctx->Pixel.MapBtoBsize = mapsize;
  283.          for (i=0;i<mapsize;i++) {
  284.         ctx->Pixel.MapBtoB[i] = CLAMP( values[i], 0.0, 1.0 );
  285.      }
  286.      break;
  287.       case GL_PIXEL_MAP_A_TO_A:
  288.          ctx->Pixel.MapAtoAsize = mapsize;
  289.          for (i=0;i<mapsize;i++) {
  290.         ctx->Pixel.MapAtoA[i] = CLAMP( values[i], 0.0, 1.0 );
  291.      }
  292.      break;
  293.       default:
  294.          gl_error( ctx, GL_INVALID_ENUM, "glPixelMapfv(map)" );
  295.    }
  296. }
  297.  
  298.  
  299.  
  300.  
  301.  
  302. void gl_GetPixelMapfv( GLcontext *ctx, GLenum map, GLfloat *values )
  303. {
  304.    GLint i;
  305.  
  306.    if (INSIDE_BEGIN_END(ctx)) {
  307.       gl_error( ctx, GL_INVALID_OPERATION, "glGetPixelMapfv" );
  308.       return;
  309.    }
  310.    switch (map) {
  311.       case GL_PIXEL_MAP_I_TO_I:
  312.          for (i=0;i<ctx->Pixel.MapItoIsize;i++) {
  313.         values[i] = (GLfloat) ctx->Pixel.MapItoI[i];
  314.      }
  315.      break;
  316.       case GL_PIXEL_MAP_S_TO_S:
  317.          for (i=0;i<ctx->Pixel.MapStoSsize;i++) {
  318.         values[i] = (GLfloat) ctx->Pixel.MapStoS[i];
  319.      }
  320.      break;
  321.       case GL_PIXEL_MAP_I_TO_R:
  322.          MEMCPY(values,ctx->Pixel.MapItoR,ctx->Pixel.MapItoRsize*sizeof(GLfloat));
  323.      break;
  324.       case GL_PIXEL_MAP_I_TO_G:
  325.          MEMCPY(values,ctx->Pixel.MapItoG,ctx->Pixel.MapItoGsize*sizeof(GLfloat));
  326.      break;
  327.       case GL_PIXEL_MAP_I_TO_B:
  328.          MEMCPY(values,ctx->Pixel.MapItoB,ctx->Pixel.MapItoBsize*sizeof(GLfloat));
  329.      break;
  330.       case GL_PIXEL_MAP_I_TO_A:
  331.          MEMCPY(values,ctx->Pixel.MapItoA,ctx->Pixel.MapItoAsize*sizeof(GLfloat));
  332.      break;
  333.       case GL_PIXEL_MAP_R_TO_R:
  334.          MEMCPY(values,ctx->Pixel.MapRtoR,ctx->Pixel.MapRtoRsize*sizeof(GLfloat));
  335.      break;
  336.       case GL_PIXEL_MAP_G_TO_G:
  337.          MEMCPY(values,ctx->Pixel.MapGtoG,ctx->Pixel.MapGtoGsize*sizeof(GLfloat));
  338.      break;
  339.       case GL_PIXEL_MAP_B_TO_B:
  340.          MEMCPY(values,ctx->Pixel.MapBtoB,ctx->Pixel.MapBtoBsize*sizeof(GLfloat));
  341.      break;
  342.       case GL_PIXEL_MAP_A_TO_A:
  343.          MEMCPY(values,ctx->Pixel.MapAtoA,ctx->Pixel.MapAtoAsize*sizeof(GLfloat));
  344.      break;
  345.       default:
  346.          gl_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
  347.    }
  348. }
  349.  
  350.  
  351. void gl_GetPixelMapuiv( GLcontext *ctx, GLenum map, GLuint *values )
  352. {
  353.    GLint i;
  354.  
  355.    if (INSIDE_BEGIN_END(ctx)) {
  356.       gl_error( ctx, GL_INVALID_OPERATION, "glGetPixelMapfv" );
  357.       return;
  358.    }
  359.    switch (map) {
  360.       case GL_PIXEL_MAP_I_TO_I:
  361.          MEMCPY(values, ctx->Pixel.MapItoI, ctx->Pixel.MapItoIsize*sizeof(GLint));
  362.      break;
  363.       case GL_PIXEL_MAP_S_TO_S:
  364.          MEMCPY(values, ctx->Pixel.MapStoS, ctx->Pixel.MapStoSsize*sizeof(GLint));
  365.      break;
  366.       case GL_PIXEL_MAP_I_TO_R:
  367.      for (i=0;i<ctx->Pixel.MapItoRsize;i++) {
  368.         values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoR[i] );
  369.      }
  370.      break;
  371.       case GL_PIXEL_MAP_I_TO_G:
  372.      for (i=0;i<ctx->Pixel.MapItoGsize;i++) {
  373.         values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoG[i] );
  374.      }
  375.      break;
  376.       case GL_PIXEL_MAP_I_TO_B:
  377.      for (i=0;i<ctx->Pixel.MapItoBsize;i++) {
  378.         values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoB[i] );
  379.      }
  380.      break;
  381.       case GL_PIXEL_MAP_I_TO_A:
  382.      for (i=0;i<ctx->Pixel.MapItoAsize;i++) {
  383.         values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoA[i] );
  384.      }
  385.      break;
  386.       case GL_PIXEL_MAP_R_TO_R:
  387.      for (i=0;i<ctx->Pixel.MapRtoRsize;i++) {
  388.         values[i] = FLOAT_TO_UINT( ctx->Pixel.MapRtoR[i] );
  389.      }
  390.      break;
  391.       case GL_PIXEL_MAP_G_TO_G:
  392.      for (i=0;i<ctx->Pixel.MapGtoGsize;i++) {
  393.         values[i] = FLOAT_TO_UINT( ctx->Pixel.MapGtoG[i] );
  394.      }
  395.      break;
  396.       case GL_PIXEL_MAP_B_TO_B:
  397.      for (i=0;i<ctx->Pixel.MapBtoBsize;i++) {
  398.         values[i] = FLOAT_TO_UINT( ctx->Pixel.MapBtoB[i] );
  399.      }
  400.      break;
  401.       case GL_PIXEL_MAP_A_TO_A:
  402.      for (i=0;i<ctx->Pixel.MapAtoAsize;i++) {
  403.         values[i] = FLOAT_TO_UINT( ctx->Pixel.MapAtoA[i] );
  404.      }
  405.      break;
  406.       default:
  407.          gl_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
  408.    }
  409. }
  410.  
  411.  
  412. void gl_GetPixelMapusv( GLcontext *ctx, GLenum map, GLushort *values )
  413. {
  414.    GLint i;
  415.  
  416.    if (INSIDE_BEGIN_END(ctx)) {
  417.       gl_error( ctx, GL_INVALID_OPERATION, "glGetPixelMapfv" );
  418.       return;
  419.    }
  420.    switch (map) {
  421.       case GL_PIXEL_MAP_I_TO_I:
  422.      for (i=0;i<ctx->Pixel.MapItoIsize;i++) {
  423.         values[i] = (GLushort) ctx->Pixel.MapItoI[i];
  424.      }
  425.      break;
  426.       case GL_PIXEL_MAP_S_TO_S:
  427.      for (i=0;i<ctx->Pixel.MapStoSsize;i++) {
  428.         values[i] = (GLushort) ctx->Pixel.MapStoS[i];
  429.      }
  430.      break;
  431.       case GL_PIXEL_MAP_I_TO_R:
  432.      for (i=0;i<ctx->Pixel.MapItoRsize;i++) {
  433.         values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoR[i] );
  434.      }
  435.      break;
  436.       case GL_PIXEL_MAP_I_TO_G:
  437.      for (i=0;i<ctx->Pixel.MapItoGsize;i++) {
  438.         values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoG[i] );
  439.      }
  440.      break;
  441.       case GL_PIXEL_MAP_I_TO_B:
  442.      for (i=0;i<ctx->Pixel.MapItoBsize;i++) {
  443.         values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoB[i] );
  444.      }
  445.      break;
  446.       case GL_PIXEL_MAP_I_TO_A:
  447.      for (i=0;i<ctx->Pixel.MapItoAsize;i++) {
  448.         values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoA[i] );
  449.      }
  450.      break;
  451.       case GL_PIXEL_MAP_R_TO_R:
  452.      for (i=0;i<ctx->Pixel.MapRtoRsize;i++) {
  453.         values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapRtoR[i] );
  454.      }
  455.      break;
  456.       case GL_PIXEL_MAP_G_TO_G:
  457.      for (i=0;i<ctx->Pixel.MapGtoGsize;i++) {
  458.         values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapGtoG[i] );
  459.      }
  460.      break;
  461.       case GL_PIXEL_MAP_B_TO_B:
  462.      for (i=0;i<ctx->Pixel.MapBtoBsize;i++) {
  463.         values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapBtoB[i] );
  464.      }
  465.      break;
  466.       case GL_PIXEL_MAP_A_TO_A:
  467.      for (i=0;i<ctx->Pixel.MapAtoAsize;i++) {
  468.         values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapAtoA[i] );
  469.      }
  470.      break;
  471.       default:
  472.          gl_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
  473.    }
  474. }
  475.  
  476.  
  477.  
  478. /**********************************************************************/
  479. /*****                       glPixelTransfer                      *****/
  480. /**********************************************************************/
  481.  
  482.  
  483. /*
  484.  * Implements glPixelTransfer[fi] whether called immediately or from a
  485.  * display list.
  486.  */
  487. void gl_PixelTransferf( GLcontext *ctx, GLenum pname, GLfloat param )
  488. {
  489.    if (INSIDE_BEGIN_END(ctx)) {
  490.       gl_error( ctx, GL_INVALID_OPERATION, "glPixelTransfer" );
  491.       return;
  492.    }
  493.  
  494.    switch (pname) {
  495.       case GL_MAP_COLOR:
  496.          ctx->Pixel.MapColorFlag = param ? GL_TRUE : GL_FALSE;
  497.      break;
  498.       case GL_MAP_STENCIL:
  499.          ctx->Pixel.MapStencilFlag = param ? GL_TRUE : GL_FALSE;
  500.      break;
  501.       case GL_INDEX_SHIFT:
  502.          ctx->Pixel.IndexShift = (GLint) param;
  503.      break;
  504.       case GL_INDEX_OFFSET:
  505.          ctx->Pixel.IndexOffset = (GLint) param;
  506.      break;
  507.       case GL_RED_SCALE:
  508.          ctx->Pixel.RedScale = param;
  509.      break;
  510.       case GL_RED_BIAS:
  511.          ctx->Pixel.RedBias = param;
  512.      break;
  513.       case GL_GREEN_SCALE:
  514.          ctx->Pixel.GreenScale = param;
  515.      break;
  516.       case GL_GREEN_BIAS:
  517.          ctx->Pixel.GreenBias = param;
  518.      break;
  519.       case GL_BLUE_SCALE:
  520.          ctx->Pixel.BlueScale = param;
  521.      break;
  522.       case GL_BLUE_BIAS:
  523.          ctx->Pixel.BlueBias = param;
  524.      break;
  525.       case GL_ALPHA_SCALE:
  526.          ctx->Pixel.AlphaScale = param;
  527.      break;
  528.       case GL_ALPHA_BIAS:
  529.          ctx->Pixel.AlphaBias = param;
  530.      break;
  531.       case GL_DEPTH_SCALE:
  532.          ctx->Pixel.DepthScale = param;
  533.      break;
  534.       case GL_DEPTH_BIAS:
  535.          ctx->Pixel.DepthBias = param;
  536.      break;
  537.       default:
  538.          gl_error( ctx, GL_INVALID_ENUM, "glPixelTransfer(pname)" );
  539.          return;
  540.    }
  541.  
  542.    if (ctx->Pixel.RedScale!=1.0F   || ctx->Pixel.RedBias!=0.0F ||
  543.        ctx->Pixel.GreenScale!=1.0F || ctx->Pixel.GreenBias!=0.0F ||
  544.        ctx->Pixel.BlueScale!=1.0F  || ctx->Pixel.BlueBias!=0.0F ||
  545.        ctx->Pixel.AlphaScale!=1.0F || ctx->Pixel.AlphaBias!=0.0F) {
  546.       ctx->Pixel.ScaleOrBiasRGBA = GL_TRUE;
  547.    }
  548.    else {
  549.       ctx->Pixel.ScaleOrBiasRGBA = GL_FALSE;
  550.    }
  551. }
  552.  
  553.  
  554.  
  555.  
  556. /*
  557.  * Pixel processing functions
  558.  */
  559.  
  560.  
  561. /*
  562.  * Apply scale and bias factors to an array of RGBA pixels.
  563.  */
  564. void gl_scale_and_bias_color( const GLcontext *ctx, GLuint n,
  565.                               GLfloat red[], GLfloat green[],
  566.                               GLfloat blue[], GLfloat alpha[] )
  567. {
  568.    GLuint i;
  569.    for (i=0;i<n;i++) {
  570.       GLfloat r = red[i]   * ctx->Pixel.RedScale   + ctx->Pixel.RedBias;
  571.       GLfloat g = green[i] * ctx->Pixel.GreenScale + ctx->Pixel.GreenBias;
  572.       GLfloat b = blue[i]  * ctx->Pixel.BlueScale  + ctx->Pixel.BlueBias;
  573.       GLfloat a = alpha[i] * ctx->Pixel.AlphaScale + ctx->Pixel.AlphaBias;
  574.       red[i]   = CLAMP( r, 0.0F, 1.0F );
  575.       green[i] = CLAMP( g, 0.0F, 1.0F );
  576.       blue[i]  = CLAMP( b, 0.0F, 1.0F );
  577.       alpha[i] = CLAMP( a, 0.0F, 1.0F );
  578.    }
  579. }
  580.  
  581.  
  582. /*
  583.  * Apply scale and bias factors to an array of RGBA pixels.
  584.  */
  585. void gl_scale_and_bias_rgba( const GLcontext *ctx, GLuint n, GLubyte rgba[][4] )
  586. {
  587.    GLfloat rbias = ctx->Pixel.RedBias   * 255.0F;
  588.    GLfloat gbias = ctx->Pixel.GreenBias * 255.0F;
  589.    GLfloat bbias = ctx->Pixel.BlueBias  * 255.0F;
  590.    GLfloat abias = ctx->Pixel.AlphaBias * 255.0F;
  591.    GLuint i;
  592.    for (i=0;i<n;i++) {
  593.       GLint r = (GLint) (rgba[i][RCOMP] * ctx->Pixel.RedScale   + rbias);
  594.       GLint g = (GLint) (rgba[i][GCOMP] * ctx->Pixel.GreenScale + gbias);
  595.       GLint b = (GLint) (rgba[i][BCOMP] * ctx->Pixel.BlueScale  + bbias);
  596.       GLint a = (GLint) (rgba[i][ACOMP] * ctx->Pixel.AlphaScale + abias);
  597.       rgba[i][RCOMP] = CLAMP( r, 0, 255 );
  598.       rgba[i][GCOMP] = CLAMP( g, 0, 255 );
  599.       rgba[i][BCOMP] = CLAMP( b, 0, 255 );
  600.       rgba[i][ACOMP] = CLAMP( a, 0, 255 );
  601.    }
  602. }
  603.  
  604.  
  605. /*
  606.  * Apply pixel mapping to an array of RGBA pixels.
  607.  */
  608. void gl_map_rgba( const GLcontext *ctx, GLuint n, GLubyte rgba[][4] )
  609. {
  610.    GLfloat rscale = (ctx->Pixel.MapRtoRsize - 1) / 255.0F;
  611.    GLfloat gscale = (ctx->Pixel.MapGtoGsize - 1) / 255.0F;
  612.    GLfloat bscale = (ctx->Pixel.MapBtoBsize - 1) / 255.0F;
  613.    GLfloat ascale = (ctx->Pixel.MapAtoAsize - 1) / 255.0F;
  614.    GLuint i;
  615.    for (i=0;i<n;i++) {
  616.       GLint ir = (GLint) (rgba[i][RCOMP] * rscale);
  617.       GLint ig = (GLint) (rgba[i][GCOMP] * gscale);
  618.       GLint ib = (GLint) (rgba[i][BCOMP] * bscale);
  619.       GLint ia = (GLint) (rgba[i][ACOMP] * ascale);
  620.       rgba[i][RCOMP] = (GLint) (ctx->Pixel.MapRtoR[ir] * 255.0F);
  621.       rgba[i][GCOMP] = (GLint) (ctx->Pixel.MapGtoG[ig] * 255.0F);
  622.       rgba[i][BCOMP] = (GLint) (ctx->Pixel.MapBtoB[ib] * 255.0F);
  623.       rgba[i][ACOMP] = (GLint) (ctx->Pixel.MapAtoA[ia] * 255.0F);
  624.    }
  625. }
  626.  
  627.  
  628. /*
  629.  * Apply pixel mapping to an array of RGBA pixels.
  630.  */
  631. void gl_map_color( const GLcontext *ctx, GLuint n,
  632.                    GLfloat red[], GLfloat green[],
  633.                    GLfloat blue[], GLfloat alpha[] )
  634. {
  635.    GLfloat rscale = ctx->Pixel.MapRtoRsize-1;
  636.    GLfloat gscale = ctx->Pixel.MapGtoGsize-1;
  637.    GLfloat bscale = ctx->Pixel.MapBtoBsize-1;
  638.    GLfloat ascale = ctx->Pixel.MapAtoAsize-1;
  639.    GLuint i;
  640.    for (i=0;i<n;i++) {
  641.       red[i]   = ctx->Pixel.MapRtoR[ (GLint) (red[i]   * rscale) ];
  642.       green[i] = ctx->Pixel.MapGtoG[ (GLint) (green[i] * gscale) ];
  643.       blue[i]  = ctx->Pixel.MapBtoB[ (GLint) (blue[i]  * bscale) ];
  644.       alpha[i] = ctx->Pixel.MapAtoA[ (GLint) (alpha[i] * ascale) ];
  645.    }
  646. }
  647.  
  648.  
  649.  
  650. /*
  651.  * Apply color index shift and offset to an array of pixels.
  652.  */
  653. void gl_shift_and_offset_ci( const GLcontext *ctx, GLuint n, GLuint indexes[] )
  654. {
  655.    GLint shift = ctx->Pixel.IndexShift;
  656.    GLint offset = ctx->Pixel.IndexOffset;
  657.    GLuint i;
  658.    if (shift > 0) {
  659.       for (i=0;i<n;i++) {
  660.          indexes[i] = (indexes[i] << shift) + offset;
  661.       }
  662.    }
  663.    else if (shift < 0) {
  664.       shift = -shift;
  665.       for (i=0;i<n;i++) {
  666.          indexes[i] = (indexes[i] >> shift) + offset;
  667.       }
  668.    }
  669.    else {
  670.       for (i=0;i<n;i++) {
  671.          indexes[i] = indexes[i] + offset;
  672.       }
  673.    }
  674. }
  675.  
  676.  
  677. /*
  678.  * Apply color index mapping to color indexes.
  679.  */
  680. void gl_map_ci( const GLcontext *ctx, GLuint n, GLuint index[] )
  681. {
  682.    GLuint mask = ctx->Pixel.MapItoIsize - 1;
  683.    GLuint i;
  684.    for (i=0;i<n;i++) {
  685.       index[i] = ctx->Pixel.MapItoI[ index[i] & mask ];
  686.    }
  687. }
  688.  
  689.  
  690. /*
  691.  * Map color indexes to rgb values.
  692.  */
  693. void gl_map_ci_to_rgba( const GLcontext *ctx, GLuint n, const GLuint index[],
  694.                         GLubyte rgba[][4] )
  695. {
  696.    GLuint rmask = ctx->Pixel.MapItoRsize - 1;
  697.    GLuint gmask = ctx->Pixel.MapItoGsize - 1;
  698.    GLuint bmask = ctx->Pixel.MapItoBsize - 1;
  699.    GLuint amask = ctx->Pixel.MapItoAsize - 1;
  700.    const GLubyte *rMap = ctx->Pixel.MapItoR8;
  701.    const GLubyte *gMap = ctx->Pixel.MapItoG8;
  702.    const GLubyte *bMap = ctx->Pixel.MapItoB8;
  703.    const GLubyte *aMap = ctx->Pixel.MapItoA8;
  704.    GLuint i;
  705.    for (i=0;i<n;i++) {
  706.       rgba[i][RCOMP] = rMap[index[i] & rmask];
  707.       rgba[i][GCOMP] = gMap[index[i] & gmask];
  708.       rgba[i][BCOMP] = bMap[index[i] & bmask];
  709.       rgba[i][ACOMP] = aMap[index[i] & amask];
  710.    }
  711. }
  712.  
  713.  
  714. /*
  715.  * Map 8-bit color indexes to rgb values.
  716.  */
  717. void gl_map_ci8_to_rgba( const GLcontext *ctx, GLuint n, const GLubyte index[],
  718.                          GLubyte rgba[][4] )
  719. {
  720.    GLuint rmask = ctx->Pixel.MapItoRsize - 1;
  721.    GLuint gmask = ctx->Pixel.MapItoGsize - 1;
  722.    GLuint bmask = ctx->Pixel.MapItoBsize - 1;
  723.    GLuint amask = ctx->Pixel.MapItoAsize - 1;
  724.    const GLubyte *rMap = ctx->Pixel.MapItoR8;
  725.    const GLubyte *gMap = ctx->Pixel.MapItoG8;
  726.    const GLubyte *bMap = ctx->Pixel.MapItoB8;
  727.    const GLubyte *aMap = ctx->Pixel.MapItoA8;
  728.    GLuint i;
  729.    for (i=0;i<n;i++) {
  730.       rgba[i][RCOMP] = rMap[index[i] & rmask];
  731.       rgba[i][GCOMP] = gMap[index[i] & gmask];
  732.       rgba[i][BCOMP] = bMap[index[i] & bmask];
  733.       rgba[i][ACOMP] = aMap[index[i] & amask];
  734.    }
  735. }
  736.  
  737.  
  738. void gl_map_ci_to_color( const GLcontext *ctx, GLuint n, const GLuint index[],
  739.                          GLfloat r[], GLfloat g[],
  740.                          GLfloat b[], GLfloat a[] )
  741. {
  742.    GLuint rmask = ctx->Pixel.MapItoRsize - 1;
  743.    GLuint gmask = ctx->Pixel.MapItoGsize - 1;
  744.    GLuint bmask = ctx->Pixel.MapItoBsize - 1;
  745.    GLuint amask = ctx->Pixel.MapItoAsize - 1;
  746.    GLuint i;
  747.    for (i=0;i<n;i++) {
  748.       r[i] = ctx->Pixel.MapItoR[index[i] & rmask];
  749.       g[i] = ctx->Pixel.MapItoG[index[i] & gmask];
  750.       b[i] = ctx->Pixel.MapItoB[index[i] & bmask];
  751.       a[i] = ctx->Pixel.MapItoA[index[i] & amask];
  752.    }
  753. }
  754.  
  755.  
  756.  
  757. void gl_shift_and_offset_stencil( const GLcontext *ctx, GLuint n,
  758.                                   GLstencil stencil[] )
  759. {
  760.    GLuint i;
  761.    GLint shift = ctx->Pixel.IndexShift;
  762.    GLint offset = ctx->Pixel.IndexOffset;
  763.    if (shift > 0) {
  764.       for (i=0;i<n;i++) {
  765.          stencil[i] = (stencil[i] << shift) + offset;
  766.       }
  767.    }
  768.    else if (shift < 0) {
  769.       shift = -shift;
  770.       for (i=0;i<n;i++) {
  771.          stencil[i] = (stencil[i] >> shift) + offset;
  772.       }
  773.    }
  774.    else {
  775.       for (i=0;i<n;i++) {
  776.          stencil[i] = stencil[i] + offset;
  777.       }
  778.    }
  779.  
  780. }
  781.  
  782.  
  783.  
  784. void gl_map_stencil( const GLcontext *ctx, GLuint n, GLstencil stencil[] )
  785. {
  786.    GLuint mask = ctx->Pixel.MapStoSsize - 1;
  787.    GLuint i;
  788.    for (i=0;i<n;i++) {
  789.       stencil[i] = ctx->Pixel.MapStoS[ stencil[i] & mask ];
  790.    }
  791. }
  792.  
  793.